Presentación

1. Introducción

Contenido

Introducción
1. La filosofía
Instalación
1. Instalación de R y RStudio
2. Instalación de RCommander
Entorno de programación de R
1. Ideas clave: Introducción a R y al análisis de datos

1. Introducción

R es un lenguaje de programación de licencia abierta y totalmente gratuito para la computación estadística y la creación de gráficos. Recientemente ha ido incrementando su popularidad en el ámbito de la ciencia de datos, y junto con Python y Java ocupa las primeras posiciones de este sector.

Como muchos otros lenguajes de programación, se fundamenta en la escritura en línea de comandos. Aún así, está extremadamente extendido el uso de la interfaz gráfica RStudio, por su practicidad y estructura. R también destaca por tener una comunidad muy activa que desarrolla paquetes, especialmente orientados a la modelización, la estadística más clásica y la visualización de datos, que son los puntos fuertes del lenguaje. R dispone de un repositorio de paquetes extensísimo, donde podemos encontrar grupos de prácticamente todas las variantes de la ciencia de datos.

A continuación, haremos una lista de algunas de las principales particularidades de R, que deberíamos conocer como usuarios y usuarias:

R es extremadamente popular en algunos sectores, y en cambio, prácticamente desconocido en otros. Está prácticamente desaparecido en un entorno más orientado a la ingeniería o la informática, pero domina en la industria farmacéutica, las finanzas, el marketing, los audiovisuales y sobre todo la academia, ya que es donde más se usa la estadística formal, uno de los puntos más fuertes de R. Su importancia como herramienta de Business Intelligence es cada vez mayor, principalmente por la simplicidad de su código y las facilidades que ofrece a la hora de hacer visualizaciones y resúmenes estadísticos.
Los modelos en R son increíblemente fáciles de usar. Como R es un lenguaje que prioriza la usabilidad, la modelización y su código asociado son mucho más sencillos que en otros lenguajes y resultan más cercanos para personas no expertas en data science.
R funciona mucho más rápidamente si utilizamos un tipo de código orientado al uso de estructuras vectoriales y planificamos correctamente las variables que necesitaremos. A diferencia de Python, por ejemplo, algunos bucles y especialmente la concatenación de variables pueden ser muy ineficientes. Pero, como ya hemos comentado, una buena planificación y el uso de alternativas que aprovechen la estructura vectorial del lenguaje para ejecutarse rápidamente pueden ayudar a compensar el punto anterior, que es su baja velocidad.
R es más complicado de aprender al principio. Sin embargo, cuando ya hayamos entrado en su lógica y ya hayamos realizado un par de proyectos, su código nos parecerá muy intuitivo y aprenderemos nuevas funcionalidades mucho más rápidamente. Los primeros pasos programando con R son más complejos que otros lenguajes más humanos como Python, donde cada tipo de objeto tiene unas funciones asociadas. En R, estas funciones, por ejemplo, las asociadas a un tipo concreto de modelo, tendremos que conocerlas de antemano o recurrir a la ayuda que nos ofrece el programa, lo que ralentiza el proceso de escritura del código al principio. Afortunadamente, la ayuda que nos ofrece R es muy completa y llena de ejemplos, y en la gran mayoría de paquetes incluyen buenos tutoriales.

El diseño de R estuvo fuertemente influenciado por dos idiomas:

S, que es un lenguaje desarrollado por AT&T Bell Laboratories y más particularmente por Rick Becker, John Chambers y Allan Wilks. S es un lenguaje de alto nivel y es un entorno para el análisis de datos y representaciones gráficas. S se puede utilizar a través del software SPlus, que ha sido comercializado por la empresa TIBCO desde 2008 link. SPlus ha sido uno de los programas estadísticos más populares y se ha establecido como un punto de referencia en la comunidad estadística hasta que R lo ha superado durante varios años.
Scheme de Sussman es un lenguaje funcional, el principio fundamental de este lenguaje es la recursividad. La ejecución y la semántica de R se derivan de Scheme.

R está desarrollado para su uso con los sistemas operativos Unix, GNU/Linux, Windows y MacOS. R tiene un sitio web oficial en http://www.R-project.org/. Es un software gratuito que se distribuye bajo los términos de la Licencia Pública GNU (regla copyleft) y es una parte integral del proyecto GNU.

1.1 La filosofía

El término “software libre” se refiere a la libertad, no al precio. Para comprender el concepto, debe pensar en “libertad de expresión”, no en “entrada libre”. El término “software libre” se refiere a la libertad de los usuarios para ejecutar, copiar, distribuir, estudiar, modificar y mejorar el software.

Más específicamente, se refiere a cuatro tipos de libertad para el usuario del software:

La libertad de ejecutar el programa, para todos los usos (libertad 0).
La libertad de estudiar cómo funciona el programa y adaptarlo a sus necesidades (libertad 1). Para este acceso al código fuente es un requisito previo.
La libertad de redistribuir copias, para ayudar a tu entorno (libertad 2).
La libertad de mejorar el programa y publicar sus mejoras en beneficio de toda la comunidad (libertad 3). Para este acceso al código fuente es un requisito previo.

“Software libre” no significa “no comercial”. El software libre debe estar disponible para uso comercial. El desarrollo de software libre comercial ya no es la excepción. Las reglas sobre cómo empaquetar una versión modificada son aceptables si no interfieren con su libertad de publicarla. Las reglas que dicen “si publica el programa por este medio, también debe hacerlo” son aceptables bajo las mismas condiciones. En el proyecto GNU, “copyleft” se utiliza para proteger estas libertades. Pero también hay software libre “sin copyleft” que no está protegido por la regla. Creemos que hay buenas razones por las cuales es mejor usar “copyleft”, pero si su programa es gratuito “sin copia”, aún podemos usarlo.

R se retroalimenta de sus usuarios a través de nuevos paquetes, los cuales (los paquetes) realizan tareas que antes no se realizaban o bién se realizaban de otra manera. La calidad de los resultados es evidente, pues es un software utilizado por investigadores para hacer sus análisis y poder publicar artículos. Está constantemente evolucionando y esta es una de las ventajas respecto a softwares de pago, de los cuales tienes que esperar la próxima versión para encontrar mejoras.

En resumen, R es un lenguaje de programación orientado al análisis estadístico y a la visualización de datos. Puede ser más complicado de aprender, al principio, que otros lenguajes, pero, debido a su creciente popularidad y versatilidad, su dominio constituye una competencia de gran valor en el mercado laboral.

2. Instalación

Contenido

2. Instalación

En este apartado vamos a ver el proceso de instalación de R, RStudio y RCommander y veremos que es muy sencillo, independientemente del sistema operativo con el que estemos trabajando.

2.1 Instalación de R y RStudio

INSTALACIÓN DE R

El primer paso que realizaremos es buscar “Install R” en Google y entraremos en la primera página que nos aparezca.

Haz clic aquí para ir a Google!

Quizás la web no es suficiente amable, ya que se trata de un proyecto libre. Tendremos que hacer clic en “Download R”, resaltado en negrita, y nos redirigirá a una página de servidores.

En principio, debería ser indiferente cuál de ellos seleccionamos, así que hacemos clic con el primero. A continuación deberemos seleccionar nuestro sistema operativo. En este caso, utilizaremos Windows para este tutorial, aunque los pasos son prácticamente idénticos para todos los sistemas operativos.

Haz clic aquí para ir al Cran.r-project.org

Clica aquí para descargar R para Windows

Una vez se ha descargado el fichero lo ejecutamos y seguimos los siguientes pasos:

INSTALACIÓN DE RStudio

El primer paso que realizaremos es buscar “download Rstudio” en Google y entraremos en la primera página que nos aparezca.

Al clicar en la primera opción Download RStudio - RStudio nos aparecerá la siguiente imagen:

Clicamos en descargar la opción Free

Una vez descargado el fichero lo ejecutamos y vamos seguimos los pasos por defecto.

Clica aquí para más información sobre descargas y instalación de R, RStudio y RCommander

Video tutorial para instalar R y RStudio

Tutorial de Youtube para instalar R y RStudio

2.2 Instalación de R Commander

R Commander, que se distribuye también bajo licencia GNU GPL, es probablemente la interfaz gráfica de R más popular debido a que es la que tiene más recorrido. Utiliza el entorno gráfico Tcl/Tk y funciona perfectamente en las distribuciones GNU/Linux (Debian, Ubuntu, openSUSE, etc) y en Windows. Puede realizar un gran número de análisis estadísticos que satisfacen incluso a los usuarios más especializados, aunque también puede operar con módulos adicionales para estadística avanzada.

R Comander no sólo permiten crear y trabajar sobre datos con el formato nativo de R, sino que también puede importar ficheros de otros muchos formatos provenientes de otros programas, incluido SPSS o Excel; los análisis están disponibles mediante un sistema de menús y cuadros de diálogo intuitivos y similares a las aplicaciones comerciales; existe una extensa documentación, mucha de ella en castellano; e introduce la programación de R, mostrando el código asociado a cada acción en los menús, por lo que se recomienda también como un buen método para aprender y profundizar en el lenguaje R.

Abrimos RStudio clicando en el icono que se habrá instalado en el escritorio, y ejecutamos el siguiente comando para la instalación de R Commander (Rcmdr):

install.packages("Rcmdr")

Nos lanzará el siguiente mensaje:

“Please select a CRAN mirror for use in this session”

Del listado seleccionamos el que este próximo a nuestra situación, Spain (Madrid) por ejemplo. Comenzará a descargar e instalar paquetes. Cuando termine ejecutamos el siguiente comando para abrir R Commander:

library(Rcmdr)

Solicitará instalar paquetes adicionales necesarios (splines, RcmdrMisc, car, sandwich, etc) así como dependencias (coda, arm, bitops, httpuv, etc). Aceptamos; en la siguiente ventana nos consultará “Instalar los paquetes desde:”, por defecto estará marcado CRAN, y así debe quedar.

Para entrar en R Commader, siempre tendremos que abrir primero RStudio y, seguidamente ejecutar el siguiente comando:

library (Rcmdr)

En la ventana inferior de R Commander “Mensajes” tendremos probablemente el siguiente “Aviso”:

The Windows version of the R Commander works best under RGui with the single-document interface (SDI).

En el menú del instalador R (RGui), abrimos “Editar” y seleccionamos “Preferencias de la interface gráfica”: en la ventana emergente marcamos SDI (Single-Document Interface), mantenmos marcado «multiple windows», picamos en el botón “Save…” de la parte inferior de la ventana y se guardará un archivo. Finalmente, reiniciamos R y los cambios en la aplicación habrán tenido efecto.

## Obten los paquetes disponibles en el Cran de R
#  names.available.packages <- rownames(available.packages())

## Extraer paquetes que contienen: Rcmdr
# Rcmdr.related.packages <- names.available.packages[grep("Rcmdr", names.available.packages)]
# Rcmdr.related.packages

## Instalarlos
# install.packages(pkgs = Rcmdr.related.packages)

Ventana de trabajo de R Commander

Tutorial de Youtube de R Commander

3. Entorno de programación de R

Contenido

3. Entorno de programación de R

En Windows, cuando se inicia el software RStudio (haga doble clic en el icono R ubicado en el escritorio), aparece una nueva interfaz con una ventana interior (la consola) y una barra de herramientas.

En Linux y macOS, para abrir una sesión, simplemente escriba R en una terminal:

R

En la siguiente figura podemos ver la interfaz de RStudio, podemos ver que la barra de menus se encuentra ubicada arriba (marcada con un 1)

Consola de RStudio

Vamos a crear un nuevo script tal y como se muestra en la imagen siguiente:

Como crear un nuevo Script

Vamos a fijar nuestro directorio de trabajo tal y como se muestra en la figura siguiente:

Fijar el directorio de trabajo

Nos fijamos que la consola se divide en 4 paneles una vez ya hemos guardado nuesto Script:

Consola dividida en 4 paneles

1 En el primer cuadrante es donde vamos a escribir el código y lo vamos a poder guardar para reproducirlo en cualquier momento.
2 En el segundo cuadrante es donde se van a guardar los objetos que vamos creando a lo largo de la sesión de trabajo.
3 En el tercer cuadrante es la consola donde aparecen los resultados numéricos y a la vez podemos ejecutar cualquier comando sin que quede grabado (para esto está el Script).
4 En el cuadrante cuarto es donde vamos a poder ver los resultados gráficos, así como nuestro directorio de trabajo y otras opciones que veremos más adelante.

3.1 Ideas clave: Introducción a R y al análisis de datos

R es un lenguaje orientado a objetos, es decir que el resultado de las instrucciones puede almacenarse en objetos que a su vez pueden usarse más tarde. Para poder dar una instrucción, el usuario debe “tener la mano”, es decir que el software debe estar listo para recibirla. Este es el caso cuando el aviso (materializado por el signo “>”) es visible en la consola. Cuando una instrucción contiene errores, aparece el mensaje Error: error de sintaxis. Si está incompleto, aparece el signo “+”, que indica que R está esperando el final de una instrucción.

Los conceptos presentados a continuación le permitirán poder utilizar R.

El operador de asignación es el signo <- o el signo =. Por lo tanto, puede llamar a cualquiera de estos operadores. Tenga en cuenta que R distingue entre letras minúsculas y MAYÚSCULAS. a es diferente de A. ES PREFERIBLE UTILIZAR LA ASIGANCIÓN CON <-

Ejemplo: asignamos al objeto x el valor 10 por:

x<-10
x

[1] 10


x=10
x

[1] 10


# ES PREFERIBLE UTILIZAR LA ASIGANCIÓN CON <-

Los diferentes comandos están separados por saltos de línea. Si desea poner varias instrucciones en la misma línea, puede usar el símbolo ; entre instrucciones Por ejemplo:

a <- 1; b <- 2

Para insertar un comentario en un programa, simplemente preceda, en cada línea, el texto a comentar con el símbolo #. Por ejemplo :

a <- 1; b <- 2
d <- a + 5 # Hemos guardado en d la suma de a + 5 
e <- 5

Para mostrar el valor de un objeto, simplemente escriba el nombre del objeto en la consola. Esto es equivalente a usar la función print(). Por ejemplo, para mostrar el valor de d:

print(d)

[1] 6

Para tener acceso directo a un comando ejecutado previamente, simplemente “regrese al historial” usando las flechas hacia arriba y hacia abajo en su teclado.
La siguiente (sessionInfo()) instrucción proporciona información sobre la sesión (versión de R utilizada, caracteres utilizados, paquetes cargados).

sessionInfo()

R version 3.6.2 (2019-12-12)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 10 x64 (build 18362)

Matrix products: default

locale:
[1] LC_COLLATE=Catalan_Spain.1252  LC_CTYPE=Catalan_Spain.1252   
[3] LC_MONETARY=Catalan_Spain.1252 LC_NUMERIC=C                  
[5] LC_TIME=Catalan_Spain.1252    

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached packages:
 [1] rAmCharts_2.1.13      RCurl_1.95-4.12       bitops_1.0-6         
 [4] jsonlite_1.6          rjson_0.2.20          rgeos_0.5-2          
 [7] raster_3.0-7          maptools_0.9-5        sp_1.3-1             
[10] maps_3.3.0            magrittr_1.5          DT_0.12              
[13] leaflet_2.0.3         ggmap_3.0.0           highcharter_0.7.0    
[16] RColorBrewer_1.1-2    htmlwidgets_1.5.1     htmltools_0.3.6      
[19] metricsgraphics_0.9.1 plotly_4.9.0          forcats_0.4.0        
[22] stringr_1.4.0         dplyr_0.8.1           purrr_0.3.2          
[25] tidyr_0.8.3           tibble_2.1.1          tidyverse_1.2.1      
[28] lubridate_1.7.4       readr_1.3.1           shinyjs_1.0          
[31] shiny_1.3.2           png_0.1-7             ggplot2_3.2.1        
[34] knitr_1.23            vembedr_0.1.3         flexdashboard_0.5.1.1

loaded via a namespace (and not attached):
 [1] nlme_3.1-142        xts_0.11-2          httr_1.4.1         
 [4] tools_3.6.2         backports_1.1.4     R6_2.4.1           
 [7] lazyeval_0.2.2      colorspace_1.4-1    withr_2.1.2        
[10] tidyselect_0.2.5    curl_3.3            compiler_3.6.2     
[13] cli_2.0.1           rvest_0.3.5         xml2_1.2.0         
[16] scales_1.0.0        digest_0.6.23       foreign_0.8-72     
[19] rmarkdown_2.1       pipeR_0.6.1.3       jpeg_0.1-8.1       
[22] pkgconfig_2.0.3     rlang_0.4.4         readxl_1.3.1       
[25] TTR_0.23-6          rstudioapi_0.11     quantmod_0.4-15    
[28] generics_0.0.2      zoo_1.8-6           crosstalk_1.0.0    
[31] rlist_0.4.6.1       Rcpp_1.0.1          munsell_0.5.0      
[34] fansi_0.4.1         stringi_1.4.4       whisker_0.3-2      
[37] yaml_2.2.0          plyr_1.8.4          grid_3.6.2         
[40] promises_1.0.1      crayon_1.3.4        lattice_0.20-38    
[43] haven_2.1.0         hms_0.5.3           pillar_1.4.3       
[46] igraph_1.2.4.1      codetools_0.2-16    glue_1.3.1         
[49] evaluate_0.14       data.table_1.12.2   modelr_0.1.4       
[52] vctrs_0.2.2         httpuv_1.5.1        RgoogleMaps_1.4.5.2
[55] cellranger_1.1.0    gtable_0.3.0        assertthat_0.2.1   
[58] xfun_0.12           mime_0.6            xtable_1.8-4       
[61] broom_0.5.2         later_0.8.0         viridisLite_0.3.0

Las siguientes dos instrucciones (equivalentes) se utilizan para obtener la lista de objetos que se han creado en la sesión actual:

ls()

[1] "a"        "b"        "d"        "e"        "faithful" "x"

objects()

[1] "a"        "b"        "d"        "e"        "faithful" "x"

La siguiente instrucción elimina el objeto cuyo nombre(s) se proporciona como argumento. Por ejemplo, para eliminar objetos a y b:

rm(a, b)
ls()

[1] "d"        "e"        "faithful" "x"

Para eliminar todos los objetos creados en la sesión actual, hacemos:

rm(list = ls())

Nota: arriba, no usamos la letra c para definir un nuevo objeto, porque la letra c es una función predefinida de R que veremos muy rápidamente. En general, se recomienda no nombrar un nuevo objeto con un nombre ya utilizado por R (por ejemplo, una función, una palabra clave como for o while).

En este módulo hemos realizado los primeros pasos con R y RStudio. A continuación, haremos un repaso de las ideas más importantes que han aparecido:

R es un conocido lenguaje de programación que ha crecido enormemente en los últimos años. Se caracteriza por estar totalmente orientado a la usabilidad, modelización y visualización, y está ampliamente extendido en muchos sectores.
Hemos instalado R y su interfaz gráfica RStudio, a la vez que hemos explorado las funcionalidades principales de RStudio, como por ejemplo:
- Visualización de los objetos creados.
- Estructura y legibilidad del código.
- Asistentes de importación.
- Gestión de scripts y de proyectos.

Mapa

Diagrama de barras (1)

Nuve de puntos

Diagrama de caja

Serie de tiempo (1)

Histograma

Nuve de puntos con regresión lineal

Diagrama de barras (2)

Serie de tiempo (2)

1.1 Objetos

1.1.1 Tipos de objetos

1.Introducción

Para aprovechar al máximo el lenguaje R, se necesitará una sólida comprensión de los tipos de datos básicos y las estructuras de datos y cómo operar con ellos.

Es muy importante comprender las estructuras de datos porque estos son los objetos que se manipularán diariamente en R. Tratar las conversiones de objetos es una de las fuentes más comunes de frustración para los principiantes.

Todo en R es un objeto. R tiene 6 tipos de datos básicos.

carácter
numérico (real o decimal)
entero
lógico
complejo

Los elementos de estos tipos de datos se pueden combinar para formar estructuras de datos, como los vectores atómicos. Cuando llamamos a un vector atómico, queremos decir que el vector solo contiene datos de un solo tipo de datos. A continuación hay ejemplos de vectores de caracteres atómicos, vectores numéricos, vectores enteros, etc.

carácter: "Hola"
numérico: 2
entero: 2L (la L le dice a R que almacene esto como un entero)
lógico: TRUE,FALSE
complejo: 1 + 4i (números complejos con partes reales e imaginarias)

R proporciona muchas funciones para examinar características de vectores y otros objetos, por ejemplo

class() - ¿que tipo de objeto es (high-level)?
typeof() - ¿cual es el tipo de dato del objeto (low-level)?
length() - ¿que longitud tiene?
attributes() - ¿tiene metadata?

Vamos a ver algunos ejemplos:

Creamos la variable x y le asignamos "dataset" que son carácters

# Ejemplo
x<-"dataset"
typeof(x)

[1] "character"

Probamos con la función attributes(x)

# Ejemplo
attributes(x)

NULL

Creamos un vector que va del 1 al 10

y <- 1:10
y

 [1]  1  2  3  4  5  6  7  8  9 10

Comprobamos el tipo de objeto de y

typeof(y)

[1] "integer"

Comprobamos la clase de objeto de y

class(y)

[1] "integer"

Comprobamos la longitud del objeto y

length(y)

[1] 10

R tiene varias estructuras de datos. Estas incluyen:

atomic vector
factores
matrices
listas
data frame

1.1.2 Vectores

1. Introducción

Un vector es la estructura de datos más común y básica en R y es prácticamente el caballo de batalla de R. Técnicamente, los vectores pueden ser de dos tipos:

vectores atómicos
listas

aunque el término “vector” se refiere más comúnmente a los tipos atómicos, no a las listas.

Los vectores generalmente se construyen a partir de la función de colector c (). Los principales tipos de objetos se presentan a continuación.

1.1. Tipo numérico

El tipo numérico contiene valores reales. La función is.numeric () le permite probar que un objeto contiene elementos de tipo numérico.

a.numeric <- c(1.2, 3.5, 5.4, 6.2, 8.1)
is.numeric(a.numeric)

[1] TRUE

1.2 Tipo entero

Para construir un vector que contenga elementos de tipo entero, agregamos el sufijo “L” al número entero. La ventaja de usar el tipo de entero en lugar de numérico es que un entero ocupa menos espacio de memoria que un doble. Verificamos que un objeto contiene muchos elementos del tipo entero con la función is.integer ():

a.integer <- c(1L, 3L, 5L, 6L, 8L)
is.integer(a.integer)

[1] TRUE

Comprobamos que es numérico:

is.numeric(a.integer)

[1] TRUE

1.3 Tipo carácter

El vector tipo carácter contiene cadenas de carácteres.

a.character <- c("Marta", "Pablo", "Anna", "Joan")
is.character(a.character)

[1] TRUE

1.4 Tipo lógico

El tipo lógico solo contiene dos posibilidades TRUE (T también se acepta) y FALSE (F también se acepta). No se utilizan las comillas "hola" como si se hace con el tipo carácter.

a.logical <- c(TRUE, FALSE, FALSE, TRUE)
is.logical(a.logical)

[1] TRUE

2. Pasar de unos a otros

A veces puede necesitar cambiar de un tipo a otro. Tome por ejemplo el vector a.logical y observe el número de veces que ha aparecido el valor TRUE. Para hacer esto, podemos usar la función sum() que se aplica al tipo numérico. Al aplicar la función sum(), si R reconoce el tipo lógico, lo convertirá automáticamente a numérico (TRUE tomará el valor 1 y FALSE el valor 0). Por ejemplo :

sum(a.logical)

[1] 2

Lo mismo es cierto para todas las operaciones de cálculo elementales (+, -, /, etc.) que se aplican a los tipos numéricos. Si se aplican a un tipo lógico, la conversión a numérico será automática:

a.logical + 5

[1] 6 5 5 6

La conversión de un tipo a otro rara vez se realiza automáticamente. Para hacer esto, será necesario utilizar las funciones proporcionadas para este propósito.

2.1 Pasar de numérico a carácter (y al revés)

Puede usar la función as.character() para transformar un vector numérico (o lógico) en un carácter.

De numérico a carácter

as.character(a.numeric)

[1] "1.2" "3.5" "5.4" "6.2" "8.1"

De lógico a carácter

as.character(a.logical)

[1] "TRUE"  "FALSE" "FALSE" "TRUE"

Para transformar un carácter en numérico, esto es posible si y solo si la cadena de caracteres contiene solo números.

No funciona!

as.numeric(a.character)

[1] NA NA NA NA

Si funciona!

as.numeric(c("12.56","23.92","0.123","99"))

[1] 12.560 23.920  0.123 99.000

2.2 Pasar un vector lógico (y al revés)

Para transformar un carácter o un valor numérico en lógico, las cadenas de caracteres deben ser iguales a “TRUE”, “T”, “FALSE” o “F” y los valores numéricos deben ser iguales a 0 o 1.

No funciona!

as.logical(a.character)

[1] NA NA NA NA

Si funciona!

as.logical(c("FALSE", "T", "FALSE"))

[1] FALSE  TRUE FALSE

O también

as.logical(c(0, 1, 0))

[1] FALSE  TRUE FALSE

3. Comparación de vectores

Los operadores de comparación clásicos son > (mayor),>= (mayor o igual), == (igual) , != (diferente), <= (menor o igual), <. Cuando estos operadores se aplican a vectores, el resultado devuelto es un vector de tipo lógico que, por lo tanto, indica VERDADERO si la condición se ha cumplido y FALSO de lo contrario.

También se pueden combinar varios a la vez con O |, que se cumpla una condición o la otra (más grande que 5 o más pequeño que 3) y también Y & que se cumpla una condición y la otra (más grande que 5 y más pequeño que 8).

x <- c(1, 2, 3, 4, 5, 6, 7, 9, 11)
y <- c("oui", "non", "oui", "oui", "non", "non", "oui", "oui", "peut-être", "non")

El siguiente comando devuelve qué elementos de x son mayores o iguales que 5.

x >= 5

[1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Para cadenas de caracteres, esencialmente usaremos el operador == y el operador !=:

y == "oui"

 [1]  TRUE FALSE  TRUE  TRUE FALSE FALSE  TRUE  TRUE FALSE FALSE

y != "oui"

 [1] FALSE  TRUE FALSE FALSE  TRUE  TRUE FALSE FALSE  TRUE  TRUE

3.1 Extaer elementos de un vector

Se puede extraer un subconjunto de un vector colocando un vector entre corchetes [] que contenga los índices correspondientes a los valores que queremos mantener.

Por ejemplo, podemos extraer los valores primero, segundo, cuarto y sexto del vector x de la siguiente manera:

x[c(1:2, 4, 6)]

[1] 1 2 4 6

Por el contrario, es posible excluir estos mismos valores colocando el signo - antes del vector índice:

x[-c(1:2, 4, 6)]

[1]  3  5  7  9 11

Extraemos del vector x los valores mayores a 3 y menores a 11 mediante el comando:

x[x>3 & x<11]

[1] 4 5 6 7 9

Extraemos del vector x los valores menores a 3 o mayores a 6 mediante el comando:

x[x<3 | x>6]

[1]  1  2  7  9 11

Para seleccionar valores iguales a “sí” en y, usamos el operador ==:

y[y == "oui"]

[1] "oui" "oui" "oui" "oui" "oui"

3.2 Funciones que generan vectores

rep()
1:10
seq()
rnorm()

rep()

Podemos crear un vector de tamaño 10, repitiendo el número 2 diez veces.

rep(2, 10)

 [1] 2 2 2 2 2 2 2 2 2 2

1:10

Con la opción : indicamos de donde a donde queremos que el vector vaya siempre con números enteros. 1:10 creará un vector que irá desde 1 hasta 10 con todos los enteros que hay en medio.

n <- 10 
1:n

 [1]  1  2  3  4  5  6  7  8  9 10

seq()

Con la función seq, creamos un vector de 1 hasta 10, por ejemplo, con saltos de 2, es decir:

seq(1, n, by = 2)

[1] 1 3 5 7 9

También podemos crear un vector que vaya del uno al 10, y esta vez si indicamos length.out=20, creará 20 números decimales equidistantes en el intervalo [1,10].

K <- 20
seq(1, 10, length.out = K)

 [1]  1.000000  1.473684  1.947368  2.421053  2.894737  3.368421  3.842105
 [8]  4.315789  4.789474  5.263158  5.736842  6.210526  6.684211  7.157895
[15]  7.631579  8.105263  8.578947  9.052632  9.526316 10.000000

rnorm()

La función rnorm(n,mean,sd) genera nnúmeros aleatorios que provienen de una distribución Normal media mean y desviación típica sd.

(x <- rnorm(n = n, mean = 0, sd = 1))

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828

letters y LETTERS

Para construir el alfabeto (vector de carácteres) en minúsculas utilizamos letters:

letters

 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q"
[18] "r" "s" "t" "u" "v" "w" "x" "y" "z"

y para crear el alfabeto (vector de carácteres) con mayúsculas utilizamos LETTERS:

LETTERS

 [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q"
[18] "R" "S" "T" "U" "V" "W" "X" "Y" "Z"

3.3 Concatenación de vectores

Aquí, el objetivo es tomar dos vectores de tamaño n1 y n2 y construir un vector de tamaño n1+n2. Para hacer esto, usamos la función c() nuevamente: cuando los elementos son de diferentes tipos (por ejemplo, numéricos y de caracteres), entonces prevalece el tipo de caracteres. Por ejemplo, la siguiente declaración creará un vector de caracteres:

Concatenación c(x,y)

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828

y <- c("R", "es", "fantástico")
c(x, y)

 [1] "-0.374375084153622" "-1.61205391521984"  "-0.686889143084865"
 [4] "-1.25531406721944"  "2.17762110734399"   "-0.247412128369658"
 [7] "2.21275812835266"   "1.57256223758227"   "-1.46439864964145" 
[10] "0.0688828045217662" "R"                  "es"                
[13] "fantástico"

Si concatenamos dos vectores numéricos, obtenemos un vector numérico:

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828

z <- c(2,5.6,7)
c(x, z)

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828  2.0000000  5.6000000
[13]  7.0000000

Función paste()

Con la función paste podemos imprimir nuestros comentarios mezclando variables por medio:

n<-10
paste("La observación ", 1:n, " (número ", c("impar", "par"), ") sobre ", n, 
      " es igual a ", round(x, 4), sep = "")

 [1] "La observación 1 (número impar) sobre 10 es igual a -0.3744"
 [2] "La observación 2 (número par) sobre 10 es igual a -1.6121"  
 [3] "La observación 3 (número impar) sobre 10 es igual a -0.6869"
 [4] "La observación 4 (número par) sobre 10 es igual a -1.2553"  
 [5] "La observación 5 (número impar) sobre 10 es igual a 2.1776" 
 [6] "La observación 6 (número par) sobre 10 es igual a -0.2474"  
 [7] "La observación 7 (número impar) sobre 10 es igual a 2.2128" 
 [8] "La observación 8 (número par) sobre 10 es igual a 1.5726"   
 [9] "La observación 9 (número impar) sobre 10 es igual a -1.4644"
[10] "La observación 10 (número par) sobre 10 es igual a 0.0689"

Función which()

La función which devuelve las posiciones que cumplen una determinada condición, por ejemplo, which(x>4) devolverá las posiciones para las cuales el vector x es mayor que 4:

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828

which(x > 1)

[1] 5 7 8

Si queremos obtener los valores del vector que cumplen esta condición deberemos hacer:

 [1] -0.3743751 -1.6120539 -0.6868891 -1.2553141  2.1776211 -0.2474121
 [7]  2.2127581  1.5725622 -1.4643986  0.0688828

x[which(x>4)]

numeric(0)

1.1.3 Factores

1. Introducción

El tipo de factor es un tipo de vector especial en el que hay un cierto número de restricciones. Es por eso que no lo hemos incluido con los demás (numérico, entero, carácter, lógico).

Un factor es un vector que contiene solo valores predefinidos y se utiliza para describir una variable cualitativa.

Para crear un factor, podemos utilitzar la función factor() sobre un vector de caracteres. Por ejemplo:

y <- c("healthy", "healthy", "failing", "failing", "healthy", "failing", "healthy",
       "failing", "failing", "failing")
yf <- factor(y)
yf

 [1] healthy healthy failing failing healthy failing healthy failing
 [9] failing failing
Levels: failing healthy

Podemos ver que los niveles o categorías de esta variable cualitativa son 2: failing y healthy.

Si queremos saber los niveles de un factor utilizamos la función levels().

levels(yf)

[1] "failing" "healthy"

Otro ejemplo donde indicamos las categorías y que además están ordenadas:

pain<-c(0,3,2,2,1,2,0,0,3,3,1,1,3,2,0,2)

# Convertimos pain en factor y le indicamos los niveles ordenados:
factor(pain,levels = 0:3,ordered = TRUE)

 [1] 0 3 2 2 1 2 0 0 3 3 1 1 3 2 0 2
Levels: 0 < 1 < 2 < 3

# Le ponemos nombre a los niveles o categorías
levels(pain)<-c("none","mild","medium","severe")

pain

 [1] 0 3 2 2 1 2 0 0 3 3 1 1 3 2 0 2
attr(,"levels")
[1] "none"   "mild"   "medium" "severe"

Damos otro orden al factor:

pain<-as.vector(pain)
pain

 [1] 0 3 2 2 1 2 0 0 3 3 1 1 3 2 0 2


# Convertimos pain en factor y le indicamos los niveles ordenados:
factor(pain,levels = 3:0,ordered = TRUE)

 [1] 0 3 2 2 1 2 0 0 3 3 1 1 3 2 0 2
Levels: 3 < 2 < 1 < 0

# Le ponemos nombre a los niveles o categorías
levels(pain)<-c("severe","medium","mild","none")

pain

 [1] 0 3 2 2 1 2 0 0 3 3 1 1 3 2 0 2
attr(,"levels")
[1] "severe" "medium" "mild"   "none"

1.1.4 Matrices

1. Introducción

Un objeto matriz en R puede verse como una generalización del vector (1D) en 2 dimensiones. Contiene elementos del mismo tipo (carácter, numérico, entero, lógico). En general, son principalmente útiles para contener valores numéricos. Además, en estadística, si observamos p variables cuantitativas (es decir, p vectores de valores numéricos o enteros) en n observaciones, tendremos estas variables en forma de matriz con n filas y p columnas donde cada columna corresponde a una variable. Es posible que tengamos que hacer operaciones matriciales para aplicar métodos estadísticos multidimensionales como PCA (análisis de componentes principales), CA (análisis de conglomerados), etc.

Por lo tanto, una matriz es una tabla bidimensional, la primera dimensión corresponde a las filas y la segunda dimensión, a las columnas.

Una matriz de tamaño n×p se construye utilizando la función matrix() (o as.matrix(x)), a partir de un vector x de longitud nxp que contiene los datos.

(X <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 2, ncol = 3, byrow = T))

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6

Le podemos poner nombre a las columnas (colnames()) y a las filas (rownames()):

colnames(X)<-c("Mates","Fisica","Química")
rownames(X)<-c("Juan","María")
X

      Mates Fisica Química
Juan      1      2       3
María     4      5       6

Vamos a ver como podemos averiguar las dimensiones de una matriz:

Función dim()

La función dim() da las dimensiones de una matriz (filas,columnas):

dim(X)

[1] 2 3

Ejercicio: Construir las matrices siguientes que seran utilizadas a posteriori:

Respuesta

Aquí tenemos la solución:

(A <- matrix(c(1, 0, 1, 3, 2, 1), ncol = 3, byrow = T))

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    3    2    1

(B <- matrix(c(1, 2, 3, 0, 1, 2), ncol = 2, byrow = F))

     [,1] [,2]
[1,]    1    0
[2,]    2    1
[3,]    3    2

¡No era tan difícil!

1.1 Operaciones elementales

Los operadores elementales +, -, * y / llevan a cabo las operaciones término a término, por ejemplo A+2 suma 2 a todos los elementos de la matriz:

A+2

     [,1] [,2] [,3]
[1,]    3    2    3
[2,]    5    4    3

Para el producto matriz, use el operador %*%, siempre sujeto a la adecuación de las dimensiones para poder hacer el producto de matrices. En nuestro ejemplo, esto da:

A %*% B

     [,1] [,2]
[1,]    4    2
[2,]   10    4

La función t() permite obtener la transpuesta de una matriz:

t(A)

     [,1] [,2]
[1,]    1    3
[2,]    0    2
[3,]    1    1

La función solve() devuelve la inversa de una matriz simpre que sea cuadrada: (La función round() redondea los valores al número deseado de decimales)

round(solve(A%*%t(A)),2)

      [,1]  [,2]
[1,]  1.17 -0.33
[2,] -0.33  0.17

1.2 Extracción de un subconjunto

Hemos visto que podemos extraer algunos elementos de un vector. Para las matrices, la operación es idéntica, con la diferencia de que las filas y las columnas a retener deben indicarse entre corchetes []. Por ejemplo, si queremos extraer en la matriz A de la fila 2, las columnas 2 y 3 deberemos hacer lo siguiente:

# Matriz A
A

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    3    2    1

# Extracción
A[2, c(2, 3)]

[1] 2 1

1.3 Hacer un cálculo por fila (o columna): función `apply()`

Hemos visto que a menudo se usa una matriz para almacenar observaciones en individuos (filas) de varias variables (columnas). Por lo tanto, es interesante saber cómo extraer información sobre cada una de las columnas. Además, las funciones tradicionales (sum(), sd(), mean(), etc.) consideran una matriz de dimensión n × p como un vector de longitud **np*. Por ejemplo :

La suma:

sum(A)

[1] 8

La media

mean(A)

[1] 1.333333

Si queremos realizar estas mismas opercaciones solo para las filas, o solo para la columnas lo haremos con la función apply().

El primer argumento corresponde al nombre de la matriz, el segundo a la dimensión en la que vamos a realizar un cálculo (1 para un cálculo por fila y 2 para un cálculo por columna) y el último argumento corresponde a la función a aplicar. Para obtener el promedio por fila, hacemos:

Promedio por filas

apply(A, 1, mean)

[1] 0.6666667 2.0000000

¿Como se haría el promedio por columnas?

Respuesta

Aquí tenemos la solución:

apply(A, 2, mean)

[1] 2 1 1

¡No era tan difícil!

Podemos ver que tipo de objeto devuelve la función apply():

class(apply(A, 2, mean))

[1] "numeric"

typeof(apply(A, 2, mean))

[1] "double"

is.vector(apply(A, 2, mean))

[1] TRUE

1.4 Funciones útiles para matrices

Las funciones cbind() y rbind () se utilizan para concatenar (vertical u horizontalmente) matrices. Estas dos funciones también funcionan con Dataframes. Por ejemplo :

De forma vertical:

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    3    2    1

     [,1] [,2]
[1,]    1    0
[2,]    2    1
[3,]    3    2

rbind(A, t(B))

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    3    2    1
[3,]    1    2    3
[4,]    0    1    2

De forma horizontal

cbind(t(A),B)

     [,1] [,2] [,3] [,4]
[1,]    1    3    1    0
[2,]    0    2    2    1
[3,]    1    1    3    2

Continuaremos en la siguiente sección con los Arrays.

1.1.5 Arrays

1. Introducción

Los arrays son los objetos de R que pueden almacenar datos en más de dos dimensiones. Por ejemplo: si creamos una matriz de dimensión (2, 3, 4), entonces se crean 4 matrices, cada una con 2 filas y 3 columnas. Las matrices solo pueden almacenar tipos de datos.

Se crea un array utilizando la función array(). Toma vectores como entrada y usa los valores en el parámetro dim para crear un array.

El siguiente ejemplo crea un array de dos matrices de 3x3 cada una con 3 filas y 3 columnas.

# Se crean dos vectores de longitudes diferentes
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Estos vecotres son el input para la función.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

Creamos un array vacio o bien con zeros:

a <- array(numeric(),c(2,3,4))
a <- array(0,c(2,3,4))

result[, ,1]<-matrix(1:9,nrow = 3)

Si instalamos y cargamos la librería abind tenemos nuevas opciones:

library(abind)
a <- abind(a, matrix(5,nrow=2,ncol=3), along=3)

1.1.6 Listas

1. Introducción

Las listas son diferentes de los vectores porque pueden estar formadas por elementos de todo tipo. Por ejemplo, una lista puede contener un vector numérico, una matriz de caracteres y tantos elementos como desee.

El objeto a contiene:

Un vector de enteros.
Una cadena de caracteres.
Un escalar.
Una lista compuesta de dos elementos (dos escalares)

a <- list(un_vector = 1:3, 
          un_caracter = "a string",
          un_escalar = pi, 
          una_lista = list(-1, -5))

Para acceder a los elementos de una lista cuyos elementos tienen un nombre (como está aquí), se puede usar el signo $, seguido del nombre del componente para recuperar. Por ejemplo :

a$un_vector

[1] 1 2 3

Si queremos acceder a la segunda posición del vector utilizamos los corchetes [] indicando en el interior la indexación requerida.

a$un_vector[2]

[1] 2

El siguiente gráfico ilustra como se accede a los diferentes partes de una lista:

¿Como accederías al valor 2 del vector?

Respuesta:

a[[1]][2]

[1] 2

¿Como accederías a la lista que está dentro?

Respuesta:

a[[4]]

[[1]]
[1] -1

[[2]]
[1] -5

¿Y al segundo elemento de la lista -5?

Respuesta:

a[[4]][[2]]

[1] -5

¡Felicidades! Ya sabes utilizar las listas

Solo una cosa más de momento…

Para aplicar una función a cada elemento de una lista, usamos la función lapply() con el nombre de la lista como primer argumento y como segundo argumento, la función que se aplica a cada elemento de la lista. Por ejemplo, para conocer el tamaño de cada elemento de la lista, hacemos:

lapply(a, length)

$un_vector
[1] 3

$un_caracter
[1] 1

$un_escalar
[1] 1

$una_lista
[1] 2

1.1.7 data.frames

1. Introducción

El data.frame es el objeto más importante en R, desde el punto de vista estadístico. Es una matriz bidimensional, cuyas columnas, a diferencia de las matrices, pueden ser de diferentes tipos. Por lo tanto, esto permite tener, en un solo objeto, observaciones sobre numerosos individuos de variables cuantitativas y cualitativas, formas habituales de un conjunto de datos. Asumiremos que el tamaño de las líneas corresponde a las n observaciones y las columnas corresponden a la p variables.

Un data.frame comparte propiedades de matriz y de lista.

La construcción de un data.frame se puede hacer forzando a un objeto a convertirse en una estructura de datos (con as.data.frame ()) o, lo que no es tan común, construyéndolo directamente con la función data.frame( ). Pero la mayoría de las veces, data.frame proviene de la importación de un conjunto de datos (consulte el párrafo “1.2 Importar datos”.

Si consideramos los siguientes vectores correspondientes a las características observadas en 6 estudiantes:

edad <- c(20, 21, 20, 25, 29, 22)
talla <- c(165, 155, 150, 170, 175, 180)
sexo <- c("F", "F", "F", "M", "M", "M")

Creamos un data.farme de la siguiente manera:

don <- data.frame(edad, talla, sexo)

2. Atributos

Dimensión

dim(don)

[1] 6 3

Equivalente a utilizar nrow() et ncol():

nrow(don)

[1] 6

ncol(don)

[1] 3

Los nombres de las filas y las columnas los podemos averiguar con las funciones: row.names() y colnames() (o names()) :

row.names(don)

[1] "1" "2" "3" "4" "5" "6"

colnames(don)

[1] "edad"  "talla" "sexo"

names(don)

[1] "edad"  "talla" "sexo"

Podemos asignar nombres a las columnas de la siguiente manera:

row.names(don) <- c("Sonia", "José", "Marta", "Mateo", "Antonio", "Rosa")

El tipo de columnas de una data.frame lo sabremos con la función str():

str(don)

'data.frame':   6 obs. of  3 variables:
 $ edad : num  20 21 20 25 29 22
 $ talla: num  165 155 150 170 175 180
 $ sexo : Factor w/ 2 levels "F","M": 1 1 1 2 2 2

3. Concatenación

Podemos tener la necesidad de añadir filas o columnas a nuestro data.frame. Veremos a continuación como hacerlo.

3.1 Concatenación de un vector en columna

Primera opción

don$diploma <- as.factor(c("DU", "M2", "M2", "DU", "DU", "M2"))

Segunda opción

don[,"diploma"] <- as.factor(c("DU", "M2", "M2", "DU", "DU", "M2"))

Tercera opción

don <- cbind(don, pais = c("ESP", "FR", "ESP", "CAM", "HAI", "BF"))

str(don)

'data.frame':   6 obs. of  5 variables:
 $ edad   : num  20 21 20 25 29 22
 $ talla  : num  165 155 150 170 175 180
 $ sexo   : Factor w/ 2 levels "F","M": 1 1 1 2 2 2
 $ diploma: Factor w/ 2 levels "DU","M2": 1 2 2 1 1 2
 $ pais   : Factor w/ 5 levels "BF","CAM","ESP",..: 3 4 3 2 5 1

don$diploma<-as.factor(don$diploma)
str(don)

'data.frame':   6 obs. of  5 variables:
 $ edad   : num  20 21 20 25 29 22
 $ talla  : num  165 155 150 170 175 180
 $ sexo   : Factor w/ 2 levels "F","M": 1 1 1 2 2 2
 $ diploma: Factor w/ 2 levels "DU","M2": 1 2 2 1 1 2
 $ pais   : Factor w/ 5 levels "BF","CAM","ESP",..: 3 4 3 2 5 1

Nota: para la adición de una columna vector a un data.frame sea posible, el tamaño de la columna del vector debe ser igual al número de filas del data.frame, de lo contrario aparecerá un mensaje de error. Para convencerse de ello, intente ejecutar las siguientes instrucciones:

#don[,"diploma"] <- c("DU", "M2", "M2", "DU", "DU", "M2","DU",, "M2", "DU", "DU")

Como siempre podemos ver la estructura del data.frame con la función str():

str(don)

'data.frame':   6 obs. of  5 variables:
 $ edad   : num  20 21 20 25 29 22
 $ talla  : num  165 155 150 170 175 180
 $ sexo   : Factor w/ 2 levels "F","M": 1 1 1 2 2 2
 $ diploma: Factor w/ 2 levels "DU","M2": 1 2 2 1 1 2
 $ pais   : Factor w/ 5 levels "BF","CAM","ESP",..: 3 4 3 2 5 1

3.2 Concatenación de un vector en columna

Para agregar un vector de línea a un data.frame, puede usar la función rbind(). Como antes, el tamaño del vector de línea debe ser igual al número de columnas en el data.frame.

don <- rbind(don, c(21, 180, "F", "DU", "ESP"))

Vamos a ver los nombres de las filas o individuos:

row.names(don)

[1] "Sonia"   "José"    "Marta"   "Mateo"   "Antonio" "Rosa"    "7"

Nota: Es importante enfatizar que la función data.frame() convierte automáticamente la variable de sexo en un factor cuando proviene de un vector de caracteres. Esta es una peculiaridad de la clase data.frame donde las variables cualitativas serán asimiladas por defecto al factor.

4. Añadir un vector linea al data.frame

Para agregar un vector de línea a un data.frame, puede usar la función rbind(). Como antes, el tamaño del vector de línea debe ser igual al número de columnas en el data.frame.

(don <- rbind(don, c(21, 180, "F", "DU", "FR")))

        edad talla sexo diploma pais
Sonia     20   165    F      DU  ESP
José      21   155    F      M2   FR
Marta     20   150    F      M2  ESP
Mateo     25   170    M      DU  CAM
Antonio   29   175    M      DU  HAI
Rosa      22   180    M      M2   BF
7         21   180    F      DU  ESP
8         21   180    F      DU   FR

Nota: Observamos que se ha asignado un nombre de línea por defecto a la observación. Este es el número de línea expresado en caracteres.

row.names(don)

[1] "Sonia"   "José"    "Marta"   "Mateo"   "Antonio" "Rosa"    "7"      
[8] "8"

row.names(don)<-c("Sonia","José","Marta","Mateo","Antonio","Rosa","Rosario","Andrés")
don

        edad talla sexo diploma pais
Sonia     20   165    F      DU  ESP
José      21   155    F      M2   FR
Marta     20   150    F      M2  ESP
Mateo     25   170    M      DU  CAM
Antonio   29   175    M      DU  HAI
Rosa      22   180    M      M2   BF
Rosario   21   180    F      DU  ESP
Andrés    21   180    F      DU   FR

5. Las funciones `rbind()` y `cbind()`

La concatenación de data.frames entre ellos se puede hacer a través de las funciones cbind() y rbind() que ya hemos usado con matrices. Esto es posible bajo ciertas restricciones. Entre estas limitaciones:

Respecto a las dimensiones (número de columnas iguales si la concatenación de individuos, número de filas iguales si la concatenación de variables),
Respeto a los nombres de las columnas si hacemos una concatenación de individuos,

Por ejemplo, para agregar nuevas personas:

don2 <- data.frame(edad = c(20, 21), talla = c(180, 175), sexo = c("M", "F"), diploma = c("DU", "DU"), pais = c("FR", "ESP"))
row.names(don2) <- c("Pedro", "Sonia")
don <- rbind(don, don2)
don

        edad talla sexo diploma pais
Sonia     20   165    F      DU  ESP
José      21   155    F      M2   FR
Marta     20   150    F      M2  ESP
Mateo     25   170    M      DU  CAM
Antonio   29   175    M      DU  HAI
Rosa      22   180    M      M2   BF
Rosario   21   180    F      DU  ESP
Andrés    21   180    F      DU   FR
Pedro     20   180    M      DU   FR
Sonia1    21   175    F      DU  ESP

¡Nos podemos fijar que como ya extistía una Sonia le ha añadido a la siguiente Sonia un 1!

don$edad<-as.numeric(don$edad)
don$talla<-as.numeric(don$edad)
str(don)

'data.frame':   10 obs. of  5 variables:
 $ edad   : num  20 21 20 25 29 22 21 21 20 21
 $ talla  : num  20 21 20 25 29 22 21 21 20 21
 $ sexo   : Factor w/ 2 levels "F","M": 1 1 1 2 2 2 1 1 2 1
 $ diploma: Factor w/ 2 levels "DU","M2": 1 2 2 1 1 2 1 1 1 1
 $ pais   : Factor w/ 5 levels "BF","CAM","ESP",..: 3 4 3 2 5 1 3 4 4 3

6. Las función `merge()`

Para concatenar data.frames entre ellos, recomendaremos el uso de la función merge() en vez de cbind() porque la función merge() realiza más comprobaciones para asegurarse de que vamos a vincular las buenas observaciones. Por ejemplo, supongamos que tenemos un data.frame que contiene dos columnas, sabiendo que el nombre de las observaciones está contenido esta vez en la columna de nombre. Además, cambiamos el orden de los nombres en comparación con la tabla anterior:

don3 <- data.frame(nota_algebra = c(18, 10, 8, 15, 20, 5, 17, 12, 8,4),
                   nom = c("Mateo", "José", "Sonia", "Pedro", "Andrés", 
                           "Antonio", "Sonia1", "Rosario", "Marta","Rosa"))

Si ahora aplicamos cbind()

cbind(don, don3)

        edad talla sexo diploma pais nota_algebra     nom
Sonia     20    20    F      DU  ESP           18   Mateo
José      21    21    F      M2   FR           10    José
Marta     20    20    F      M2  ESP            8   Sonia
Mateo     25    25    M      DU  CAM           15   Pedro
Antonio   29    29    M      DU  HAI           20  Andrés
Rosa      22    22    M      M2   BF            5 Antonio
Rosario   21    21    F      DU  ESP           17  Sonia1
Andrés    21    21    F      DU   FR           12 Rosario
Pedro     20    20    M      DU   FR            8   Marta
Sonia1    21    21    F      DU  ESP            4    Rosa

¡Se ha añadido la nota de álgebra pero no en el lugar adecuado!

En cambio, si utilizamos merge() y indicamos las columnas identificativas, que son en don row.names y en don3 nom vemos que:

merge(don, don3, by.x = "row.names", by.y = "nom")

   Row.names edad talla sexo diploma pais nota_algebra
1     Andrés   21    21    F      DU   FR           20
2    Antonio   29    29    M      DU  HAI            5
3       José   21    21    F      M2   FR           10
4      Marta   20    20    F      M2  ESP            8
5      Mateo   25    25    M      DU  CAM           18
6      Pedro   20    20    M      DU   FR           15
7       Rosa   22    22    M      M2   BF            4
8    Rosario   21    21    F      DU  ESP           12
9      Sonia   20    20    F      DU  ESP            8
10    Sonia1   21    21    F      DU  ESP           17

Nota: La función merge() mantiene por defecto solo las observaciones que están presentes simultáneamente en las dos tablas. Podemos, si lo deseamos, extender la selección a otras observaciones jugando con las opciones all.x =, all.y = y all =

Nota: Si queremos buscar información respecto a cualquier función nos basta con poner el interrogante y la función seguidamente:

?merge

7. Extracción de elementos por filas, columnas o selección

Filas

don["Sonia",]

      edad talla sexo diploma pais
Sonia   20    20    F      DU  ESP

O bién:

don[c(1, 3, 5),]

        edad talla sexo diploma pais
Sonia     20    20    F      DU  ESP
Marta     20    20    F      M2  ESP
Antonio   29    29    M      DU  HAI

Columnas

don[, c(2, 3)]

        talla sexo
Sonia      20    F
José       21    F
Marta      20    F
Mateo      25    M
Antonio    29    M
Rosa       22    M
Rosario    21    F
Andrés     21    F
Pedro      20    M
Sonia1     21    F

O bién

don[, c("edad", "sexo")]

        edad sexo
Sonia     20    F
José      21    F
Marta     20    F
Mateo     25    M
Antonio   29    M
Rosa      22    M
Rosario   21    F
Andrés    21    F
Pedro     20    M
Sonia1    21    F

LOS DOS A LA VEZ

don[c("Sonia", "Sonia1"), c(3, 5)]

       sexo pais
Sonia     F  ESP
Sonia1    F  ESP

Selección

don$sexo == "F"

 [1]  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE  TRUE FALSE  TRUE

don[don$sexo == "F",]

        edad talla sexo diploma pais
Sonia     20    20    F      DU  ESP
José      21    21    F      M2   FR
Marta     20    20    F      M2  ESP
Rosario   21    21    F      DU  ESP
Andrés    21    21    F      DU   FR
Sonia1    21    21    F      DU  ESP

Usando la función which()

which(don$sexo == "F")

[1]  1  2  3  7  8 10

don[which(don$sexo == "F"),]

        edad talla sexo diploma pais
Sonia     20    20    F      DU  ESP
José      21    21    F      M2   FR
Marta     20    20    F      M2  ESP
Rosario   21    21    F      DU  ESP
Andrés    21    21    F      DU   FR
Sonia1    21    21    F      DU  ESP

8. Funciones de base

Al igual que para las matrices, un cierto número de funciones permiten conocer ciertas propiedades de un data.frame. Ilustraremos estas funciones en el data.frame `mtcars que tenemos disponible en el R por defecto.

Para mostrar la primera y la última línea respectivamente, use las funciones head() y tail() con el número de líneas para mostrar como segundo argumento:

head(mtcars,15)

                    mpg cyl  disp  hp drat    wt  qsec vs am gear carb
Mazda RX4          21.0   6 160.0 110 3.90 2.620 16.46  0  1    4    4
Mazda RX4 Wag      21.0   6 160.0 110 3.90 2.875 17.02  0  1    4    4
Datsun 710         22.8   4 108.0  93 3.85 2.320 18.61  1  1    4    1
Hornet 4 Drive     21.4   6 258.0 110 3.08 3.215 19.44  1  0    3    1
Hornet Sportabout  18.7   8 360.0 175 3.15 3.440 17.02  0  0    3    2
Valiant            18.1   6 225.0 105 2.76 3.460 20.22  1  0    3    1
Duster 360         14.3   8 360.0 245 3.21 3.570 15.84  0  0    3    4
Merc 240D          24.4   4 146.7  62 3.69 3.190 20.00  1  0    4    2
Merc 230           22.8   4 140.8  95 3.92 3.150 22.90  1  0    4    2
Merc 280           19.2   6 167.6 123 3.92 3.440 18.30  1  0    4    4
Merc 280C          17.8   6 167.6 123 3.92 3.440 18.90  1  0    4    4
Merc 450SE         16.4   8 275.8 180 3.07 4.070 17.40  0  0    3    3
Merc 450SL         17.3   8 275.8 180 3.07 3.730 17.60  0  0    3    3
Merc 450SLC        15.2   8 275.8 180 3.07 3.780 18.00  0  0    3    3
Cadillac Fleetwood 10.4   8 472.0 205 2.93 5.250 17.98  0  0    3    4

tail(mtcars,3)

               mpg cyl disp  hp drat   wt qsec vs am gear carb
Ferrari Dino  19.7   6  145 175 3.62 2.77 15.5  0  1    5    6
Maserati Bora 15.0   8  301 335 3.54 3.57 14.6  0  1    5    8
Volvo 142E    21.4   4  121 109 4.11 2.78 18.6  1  1    4    2

summary(mtcars)

      mpg             cyl             disp             hp       
 Min.   :10.40   Min.   :4.000   Min.   : 71.1   Min.   : 52.0  
 1st Qu.:15.43   1st Qu.:4.000   1st Qu.:120.8   1st Qu.: 96.5  
 Median :19.20   Median :6.000   Median :196.3   Median :123.0  
 Mean   :20.09   Mean   :6.188   Mean   :230.7   Mean   :146.7  
 3rd Qu.:22.80   3rd Qu.:8.000   3rd Qu.:326.0   3rd Qu.:180.0  
 Max.   :33.90   Max.   :8.000   Max.   :472.0   Max.   :335.0  
      drat             wt             qsec             vs        
 Min.   :2.760   Min.   :1.513   Min.   :14.50   Min.   :0.0000  
 1st Qu.:3.080   1st Qu.:2.581   1st Qu.:16.89   1st Qu.:0.0000  
 Median :3.695   Median :3.325   Median :17.71   Median :0.0000  
 Mean   :3.597   Mean   :3.217   Mean   :17.85   Mean   :0.4375  
 3rd Qu.:3.920   3rd Qu.:3.610   3rd Qu.:18.90   3rd Qu.:1.0000  
 Max.   :4.930   Max.   :5.424   Max.   :22.90   Max.   :1.0000  
       am              gear            carb      
 Min.   :0.0000   Min.   :3.000   Min.   :1.000  
 1st Qu.:0.0000   1st Qu.:3.000   1st Qu.:2.000  
 Median :0.0000   Median :4.000   Median :2.000  
 Mean   :0.4062   Mean   :3.688   Mean   :2.812  
 3rd Qu.:1.0000   3rd Qu.:4.000   3rd Qu.:4.000  
 Max.   :1.0000   Max.   :5.000   Max.   :8.000

Podemos encontrar un pequeño análisis de este data.frame en el link.

1.2 Importar datos

1.2.1 FICHERO DE R

1. Introducción

Esta sección está dedicada a administrar objetos en R. Aprenderlo debería permitirle familiarizarse con las herramientas utilizadas para guardar y cargar objetos. Además, dado que R es sobre todo un software de procesamiento de datos, se dedicará un párrafo a la gestión de conjuntos de datos (importación, exportación).

Cargamos el fichero diamants.RData

load("diamants.Rdata")

Vemos que datos tenemos en forma de tabla:

#remotes::install_github('rstudio/DT')

#knitr::kable(
#  head(diamants,15), caption = 'Mostramos 15 filas del data.frame'
#)

datatable(iris, options = list(pageLength = 5))

1.2.2

1.2.3

1.3 Gráficos

1.3.1

Respuesta

Aquí tenemos la solución:

# even code
print("Hello world!")

[1] "Hello world!"

Presentación

1. Introducción

Contenido

1. Introducción

1.1 La filosofía

2. Instalación

Contenido

2. Instalación

2.1 Instalación de R y RStudio

2.2 Instalación de R Commander

3. Entorno de programación de R

Contenido

3. Entorno de programación de R

3.1 Ideas clave: Introducción a R y al análisis de datos

Mapa

Diagrama de barras (1)

Nuve de puntos

Diagrama de caja

Serie de tiempo (1)

Histograma

Nuve de puntos con regresión lineal

Diagrama de barras (2)

Serie de tiempo (2)

1.1 Objetos

1.1.1 Tipos de objetos

1.Introducción

1.1.2 Vectores

1. Introducción

1.1. Tipo numérico

1.2 Tipo entero

1.3 Tipo carácter

1.4 Tipo lógico

2. Pasar de unos a otros

2.1 Pasar de numérico a carácter (y al revés)

2.2 Pasar un vector lógico (y al revés)

3. Comparación de vectores

3.1 Extaer elementos de un vector

3.2 Funciones que generan vectores

3.3 Concatenación de vectores

1.1.3 Factores

1. Introducción

1.1.4 Matrices

1. Introducción

1.1 Operaciones elementales

1.2 Extracción de un subconjunto

1.3 Hacer un cálculo por fila (o columna): función apply()

1.4 Funciones útiles para matrices

1.1.5 Arrays

1. Introducción

1.1.6 Listas

1. Introducción

1.1.7 data.frames

1. Introducción

2. Atributos

3. Concatenación

3.1 Concatenación de un vector en columna

3.2 Concatenación de un vector en columna

4. Añadir un vector linea al data.frame

5. Las funciones rbind() y cbind()

6. Las función merge()

7. Extracción de elementos por filas, columnas o selección

8. Funciones de base

1.2 Importar datos

1.2.1 FICHERO DE R

1. Introducción

1.2.2

1.2.3

1.3 Gráficos

1.3.1

1.3.2

1.3.3

1.3 Hacer un cálculo por fila (o columna): función `apply()`

5. Las funciones `rbind()` y `cbind()`

6. Las función `merge()`